JvnWrapperCreator.java

Go to the documentation of this file.

package jvn;


//import java.io.*;
import java.io.File;
import java.io.FileWriter;
//import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Vector;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;

public class JvnWrapperCreator extends ClassLoader {

        //private static File currentFile = null;
        //private static String currentFilename = null;

        // TODO: CHECK pattern for package.
        private static Pattern pattern = Pattern.compile("^([A-Za-z][A-Za-z0-9.]*)+$");
        private static Matcher matcher;
        
        public static void main(String[] args) {
                execute(args);
        }

        private static void execute(String [] args) {
                String className;
                Vector<Method> writeMethods;
                Vector<Method> readMethods;             
                Vector<Method> normalMethods;
                JvnWrapperCreator creator;
                
                
                creator = new JvnWrapperCreator();
                writeMethods = new Vector<Method>();
                readMethods = new Vector<Method>();
                normalMethods = new Vector<Method>();

                System.out.println("Usage: JvnWrapperCreator <complete class names (without \".class\")>");
                //System.out.println("For now, classes are not supposed to have a constructor of the following form:");
                //System.out.println("public Foo(java.lang.Serializable o);");
                //System.out.println("Read the source for more details.");

                if (args.length != 0) {
                        String name;
                        for (String s : args) {
                                // Stupid bug, simple fix: don't forget to clear our
                                // internal structures for each file !
                                writeMethods.clear();
                                readMethods.clear();
                                normalMethods.clear();
                                
                                matcher = pattern.matcher(s);
                                if (matcher.matches()) {
                                        // Classes are supposed to be under the "build" folder.
                                        //currentFilename = s.replace('.', '/') + ".class";
                                        //currentFile = new File("build/" + currentFilename);
                                        name = s;
                                        //System.out.println(name);
                                        Logger.global.info("Treating class \"" + name +"\"");
                                        try {
                                                JvnWrite w;
                                                JvnRead r;

                                                //System.out.println(name);

                                                Class c = creator.loadClass(name,true);

                                                if (c != null) {

                                                        Method [] methods = c.getDeclaredMethods();
                                                        Constructor [] constructors = c.getConstructors();

                                                        //System.out.println("Methods in \"" + name + "\":");
                                                        for (Method m : methods) {
                                                                //System.out.print(m.toGenericString());
                                                                
                                                                // Don't generate wrappers for PROTECTED or PRIVATE methods !
                                                                if ((m.getModifiers() & (Modifier.PROTECTED | Modifier.PRIVATE)) != 0) {
                                                                        continue;
                                                                }

                                                                w = m.getAnnotation(JvnWrite.class);
                                                                r = m.getAnnotation(JvnRead.class);

                                                                // Do something if
                                                                // annotation @JvnWrite is present
                                                                // XOR
                                                                // annotation @JvnRead is present
                                                                // (AND makes no sense).
                                                                if ((w != null) ^ (r != null)) {
                                                                        if (w != null) {
                                                                                // Add method to list of @JvnWrite methods.
                                                                                Logger.global.info("@JvnWrite on method \"" + m.toGenericString() + "\".");
                                                                                
                                                                                writeMethods.add(m);
                                                                        }
                                                                        else {
                                                                                // Add method to list of @JvnRead methods.
                                                                                Logger.global.info("@JvnRead on method \"" + m.toGenericString() + "\".");

                                                                                readMethods.add(m);
                                                                        }
                                                                }
                                                                else if ((w != null) && (r != null)) {
                                                                        System.err.println("Having both @JvnWrite and @JvnRead on a method does not make any sense !");
                                                                }
                                                                else {
                                                                        normalMethods.add(m);
                                                                }

                                                                System.out.println("");

                                                        }
                                                        
                                                        className = name;
                                                        
                                                        generateOneFile(className, readMethods, writeMethods, normalMethods, constructors);
                                                }
                                                else {
                                                        System.err.println("Error: couldn't load class \"");
                                                }

                                        } catch (ClassNotFoundException e) {
                                                System.err.println("Error: class \"" + s + "\" not found !");
                                                e.printStackTrace();
                                        }

                                }
                                else {
                                        System.err.println("Error: invalid filename \"" + s + "\" !");
                                }
                        }

                }
                else {

                }

        }
        
        private static void generateOneFile(String wholeClassName, Vector<Method> readMethods, Vector<Method> writeMethods, Vector<Method> normalMethods, Constructor[] constructors) {
                String packageName;
                String className;
                String [] strings;
                
                Vector<Signature> signatures = new Vector<Signature>();
                
                for (Constructor c : constructors) {
                        Signature s = new Signature();
                        s.setValues(c);
                        signatures.add(s);
                }

                for (Method m : readMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }

                for (Method m : writeMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }
                
                for (Method m : normalMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }

                
                strings = wholeClassName.split("\\.");

                // Class name is the last part of the whole class name.
                if (strings.length > 1) {
                        packageName = new String(strings[0]);
                }
                else {
                        packageName = null;
                        if (strings.length != 1) {
                                // Not supposed to occur !
                                System.err.println("Incorrect class name !");
                                return; // THIS returns !
                        }
                }
                className = strings[strings.length - 1];

                // Package name is the rest of the whole class name.
                // (Hey, no string "join" operation in Java ?)
                if (packageName != null) {
                        // If there's a package name (i.e. if strings.length > 1)
                        for (int i = 1; i < strings.length - 1; i++) {
                                packageName = packageName + "." + strings[i];
                        }
                }
                
                
                
                // get & initialize the velocity engine
                VelocityEngine ve = new VelocityEngine();
                
                try {
                        ve.init();
                        
                        // get the template
                        Template t = ve.getTemplate("jvnwrappercreator.vm");
                        // create a context & add data
                        VelocityContext context = new VelocityContext();
                        context.put("className", className);
                        context.put("packageName", packageName);
                        context.put("constructorsAndMethods",signatures);
                        
                        /*for (Constructor c : constructors) {
                                System.out.println(c.toGenericString());
                                modifiers.add(Modifier.toString(c.getModifiers()));
                        }*/
                        
                        //System.out.println(className);
                        //System.out.println(packageName);
                        
                        // perform generation
                        //StringWriter writer = new StringWriter();
                        if (packageName == null) {
                                packageName = "";
                        }
                        File file = new File("src/" + packageName.replace('.', '/') + "/Jvn" + className + ".java");
                        FileWriter writer = new FileWriter(file);
                        t.merge(context, writer);
                        writer.flush();
                        //System.out.println(writer.toString());
                }
                catch (Exception e) {
                        e.printStackTrace(System.err);
                }
        }

        protected synchronized Class<?> loadClass(final String name,final boolean resolve) throws ClassNotFoundException {
                //FileInputStream fis;

        return super.loadClass(name, resolve);
        }
            
    // This attempt at loading a class, found in the Adapt example of ASM and
    // the Java Developer Almanach, doesn't work properly. With it, annotations
    // are more or less stripped - that is, they don't appear in
    // getAnnotations()
    // on methods, even though the irc.JvnWrite and irc.JvnRead classes are loaded,
    // but not kept by the JVM (loaded as many times as needed).
    // So we're giving up, after several hours of work.
        /*protected synchronized Class<?> loadClass(final String name,final boolean resolve) throws ClassNotFoundException {
                //FileInputStream fis;

        // /!\ Do not load system classes ourselves:
                //     it's forbidden and throws a security exception !
                if (name.startsWith("java.")) {
                System.out.println("Delegating loading of class \"" + name + "\" to parent.");
            return super.loadClass(name, resolve);
        }
                else {


            //fis = getResourceAsStream(currentFilename);
                try {
                        fis = new FileInputStream(currentFile);
                } catch (FileNotFoundException e1) {
                        System.err.println("Error: file \"" + currentFile.getName() + "\" not found !");
                        return null; // THIS returns !
                }

                long length = currentFile.length();

                if (length > Integer.MAX_VALUE) {
                        System.err.println("Error: file \"" + currentFile.getName() + "\" too large !");
                        return null; // THIS returns !
                }

                byte [] bytes = new byte[(int)length];

                int offset = 0;
                int numRead = 0;

                try {
                        while (offset < bytes.length && (numRead = fis.read(bytes,offset,bytes.length-offset)) >= 0) {
                                offset += numRead;
                        }
                } catch (IOException e) {
                        System.err.println("Error: couldn't read file\"" + currentFile.getName() + "\"");
                        return null; // THIS returns !
                }

                if (offset < bytes.length) {
                        System.err.println("Error: couldn't read file\"" + currentFile.getName() + "\"");
                        return null; // THIS returns !
                }

                try {
                        fis.close();
                } catch (IOException e) {
                        System.err.println("Error: couldn't close file\"" + currentFile.getName() + "\"");
                        // Supposed to be fatal ?
                }

                // returns the adapted class
                Class<?> c = defineClass(name, bytes, 0, bytes.length);
                return c;
        }
        }*/

        /*protected synchronized Class<?> findClass(final String name) throws ClassNotFoundException {
        System.out.println("findClass(\"" + name + "\")");
        return null;
        }*/
        
}

---